package com.kk.demo.unsface.two.create2;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

import com.kk.util.IOutils;

import sun.misc.Unsafe;

public class UnsafeCreateObject {

    /**
     * 获取Unsafe对象
    * 方法描述
    * @return
    * @创建日期 2016年11月18日
    */
    @SuppressWarnings("restriction")
    public static Unsafe getUnsafe() {
        Unsafe safe = null;

        Field fied = null;
        try {
            fied = Unsafe.class.getDeclaredField("theUnsafe");
            fied.setAccessible(true);
            safe = (Unsafe) fied.get(null);
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        return safe;
    }

    public static void main(String[] args) {
        UnsafeCreateObject unsafeCreate = new UnsafeCreateObject();
        // 快速创建对象
       // unsafeCreate.quickCreateObject();
        // 动态创建对象
       //unsafeCreate.quickCreate2Object();
        
        unsafeCreate.quickCreate3Object();

    }

    /**
     * 快速创建对象的方法
     * 由于unsafe是直接复杂的字节码的内存结构，所以，所有的对象都未初始化（包括属性设置的值），
     * 快速创建对象后，需要自己构造对象的值信息
    * 方法描述
    * @创建日期 2016年11月25日
    */
    public void quickCreateObject() {
        // 使用unSafe来创建对象

        Unsafe unsafe = getUnsafe();
        try {
            long startTimeUnsafe = System.nanoTime();
            MyClass unsafA = (MyClass) unsafe.allocateInstance(MyClass.class);
            // 未经构造函数，快速创建对象,所以，取出来的数据是未经构造初始化的
            System.out.println("当前值a为:" + unsafA.getA());
            System.out.println("当前值b为:" + unsafA.getB());
            System.out.println("当前值c为:" + unsafA.getC());

            // 此使用直接复杂的内存结构，非在堆上创建，效率非常的高
            long endTimeUnsafe = System.nanoTime();
            System.out.println("unsafe时间:" + (endTimeUnsafe - startTimeUnsafe));
        } catch (InstantiationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    /**
     * 快速创建对象的方法
     * 由于unsafe是直接复杂的字节码的内存结构，所以，所有的对象都未初始化（包括属性设置的值），
     * 快速创建对象后，需要自己构造对象的值信息
     * 方法描述
     * @创建日期 2016年11月25日
     */
    public void quickCreate3Object() {
        // 使用unSafe来创建对象
        
        Unsafe unsafe = getUnsafe();
        try {
            long startTimeUnsafe = System.nanoTime();
            MyClass3 unsafA = (MyClass3) unsafe.allocateInstance(MyClass3.class);
            // 未经构造函数，快速创建对象,所以，取出来的数据是未经构造初始化的
            System.out.println("当前值a为:" + unsafA.getA());
            System.out.println("当前值b为:" + unsafA.getB());
            System.out.println("当前值c为:" + unsafA.getC());
            System.out.println("当前值d为:" + unsafA.getD());
            System.out.println("当前值e为:" + unsafA.getE());
            System.out.println("当前值f为:" + unsafA.getF());
            System.out.println("当前值g为:" + unsafA.getG());
            
            // 此使用直接复杂的内存结构，非在堆上创建，效率非常的高
            long endTimeUnsafe = System.nanoTime();
            System.out.println("unsafe时间:" + (endTimeUnsafe - startTimeUnsafe));
        } catch (InstantiationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    
    /**
     * 快速创建对象的方法
     * 由于unsafe是直接复杂的字节码的内存结构，所以，所有的对象都未初始化（包括属性设置的值），
     * 快速创建对象后，需要自己构造对象的值信息
     * 方法描述
     * @创建日期 2016年11月25日
     */
    public void quickCreate2Object() {
        // 使用unSafe来创建对象
        
        Unsafe unsafe = getUnsafe();
        try {
            long startTimeUnsafe = System.nanoTime();
            MyClass2 unsafA = (MyClass2) unsafe.allocateInstance(MyClass2.class);
            long avalue = unsafA.getAvalue();
            // 未经构造函数，快速创建对象,所以，取出来的数据是未经构造初始化的
            System.out.println("当前值a为:" + avalue);
            
            // 此使用直接复杂的内存结构，非在堆上创建，效率非常的高
            long endTimeUnsafe = System.nanoTime();
            System.out.println("unsafe时间:" + (endTimeUnsafe - startTimeUnsafe));
        } catch (InstantiationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
    }

}
